package 线程andJUC;

public class Deadlock  {
    /*
    当任务有多个同步（必须是嵌套（你中有我，我中有你），程序会引发一种无限等待的状态，称之为死锁）
    前提；线程之间出现了同步嵌套才会有死锁
    特点：线程进入同步先获取锁，不出同步，不会释放锁
    即：双方互相持有对方的资源：例如  人事问你什么事死锁，你说先要给我发offer我再给你说什么是死锁，人事说不行，你要先说。。。
     */

    /*
    Lock接口提供的方法：
    public void lock()             加同步锁
    public void unlock()           释放同步锁

     */
    public static void main(String[] args) {
//        MyTicketDemo3 mtd1=new MyTicketDemo3();
//        MyTicketDemo3 mtd2=new MyTicketDemo3();
            deadLock dead=new deadLock();
            Thread t0=new Thread(dead);
            Thread t1=new Thread(dead);
            t0.start();
            t1.start();
    }
}
/*
class MyTicketDemo3 implements Runnable {
//      定义一个多线程共享的票源
    private int ticket=100;
//    在成员位置创建一个ReentrantLock对象
    Lock lock=new ReentrantLock();
//    设置线程任务：卖票
    @Override
    public void run() {
        while (true){
            if (ticket<100){
                try{
                    Thread.sleep(500);
//                    票存在，就卖票
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                //ticket--;
                //System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                finally {
//                    3.在可能出现安全问题的代码后面调用Lock接口中的方法unlock释放锁
                    lock.unlock();//无论程序是否异常，都会把所释放
                }
            }
        }
    }
}

 */
//              实现死锁
class LockA{
    private LockA(){}
    public static final LockA locka=new LockA();
}
class LockB{
    private LockB(){}
    public static final LockB lockb=new LockB();
}
//    deadlock类
class deadLock implements Runnable{
    private int i=0;
    @Override
    public void run() {
        while (true){
            if (i%2==0){
//                先进入A同步，再进入B同步
                synchronized (LockA.locka){
                    System.out.println("if...locka");
                    /*
                    synchronized (LockB.lockb){
                    System.out.println("if...lockb);
                    }
                     */
                    }
                synchronized (LockB.lockb){
                    System.out.println("if...lockb");
                }
            }else {
//                先进入B同步，再进入A同步
                synchronized (LockB.lockb) {
                    System.out.println("if...lockb");
                    /*
                    synchronized (LockA.locka){
                        System.out.println("if...locka");
                    }
                     */
                }
                    synchronized (LockA.locka) {
                        System.out.println("if...locka");
                    }
            }
            i++;
        }
    }
}